Termination w.r.t. Q proof of /tmp/tmpVMd8b3/thiemann06.trs

Termination w.r.t. Q of the following Term Rewriting System could be proven:

Q restricted rewrite system:
The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
average(x, y) → if(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
if(true, b1, b2, b3, x, y) → if2(b1, b2, b3, x, y)
if(false, b1, b2, b3, x, y) → average(p(x), s(y))
if2(true, b2, b3, x, y) → 0
if2(false, b2, b3, x, y) → if3(b2, b3, x, y)
if3(true, b3, x, y) → 0
if3(false, b3, x, y) → if4(b3, x, y)
if4(true, x, y) → s(0)
if4(false, x, y) → average(s(x), p(p(y)))

Q is empty.

↳ QTRS

  ↳ Overlay + Local Confluence

Q restricted rewrite system:
The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
average(x, y) → if(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
if(true, b1, b2, b3, x, y) → if2(b1, b2, b3, x, y)
if(false, b1, b2, b3, x, y) → average(p(x), s(y))
if2(true, b2, b3, x, y) → 0
if2(false, b2, b3, x, y) → if3(b2, b3, x, y)
if3(true, b3, x, y) → 0
if3(false, b3, x, y) → if4(b3, x, y)
if4(true, x, y) → s(0)
if4(false, x, y) → average(s(x), p(p(y)))

Q is empty.

The TRS is overlay and locally confluent. By [19] we can switch to innermost.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
average(x, y) → if(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
if(true, b1, b2, b3, x, y) → if2(b1, b2, b3, x, y)
if(false, b1, b2, b3, x, y) → average(p(x), s(y))
if2(true, b2, b3, x, y) → 0
if2(false, b2, b3, x, y) → if3(b2, b3, x, y)
if3(true, b3, x, y) → 0
if3(false, b3, x, y) → if4(b3, x, y)
if4(true, x, y) → s(0)
if4(false, x, y) → average(s(x), p(p(y)))

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

AVERAGE(x, y) → LE(y, s(0))
IF(false, b1, b2, b3, x, y) → P(x)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
IF(false, b1, b2, b3, x, y) → AVERAGE(p(x), s(y))
LE(s(x), s(y)) → LE(x, y)
IF4(false, x, y) → P(y)
IF4(false, x, y) → P(p(y))
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(x, y) → LE(x, 0)
AVERAGE(x, y) → LE(y, 0)
AVERAGE(x, y) → LE(y, s(s(0)))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
average(x, y) → if(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
if(true, b1, b2, b3, x, y) → if2(b1, b2, b3, x, y)
if(false, b1, b2, b3, x, y) → average(p(x), s(y))
if2(true, b2, b3, x, y) → 0
if2(false, b2, b3, x, y) → if3(b2, b3, x, y)
if3(true, b3, x, y) → 0
if3(false, b3, x, y) → if4(b3, x, y)
if4(true, x, y) → s(0)
if4(false, x, y) → average(s(x), p(p(y)))

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(x, y) → LE(y, s(0))
IF(false, b1, b2, b3, x, y) → P(x)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
IF(false, b1, b2, b3, x, y) → AVERAGE(p(x), s(y))
LE(s(x), s(y)) → LE(x, y)
IF4(false, x, y) → P(y)
IF4(false, x, y) → P(p(y))
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(x, y) → LE(x, 0)
AVERAGE(x, y) → LE(y, 0)
AVERAGE(x, y) → LE(y, s(s(0)))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
average(x, y) → if(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
if(true, b1, b2, b3, x, y) → if2(b1, b2, b3, x, y)
if(false, b1, b2, b3, x, y) → average(p(x), s(y))
if2(true, b2, b3, x, y) → 0
if2(false, b2, b3, x, y) → if3(b2, b3, x, y)
if3(true, b3, x, y) → 0
if3(false, b3, x, y) → if4(b3, x, y)
if4(true, x, y) → s(0)
if4(false, x, y) → average(s(x), p(p(y)))

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 7 less nodes.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LE(s(x), s(y)) → LE(x, y)

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
average(x, y) → if(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
if(true, b1, b2, b3, x, y) → if2(b1, b2, b3, x, y)
if(false, b1, b2, b3, x, y) → average(p(x), s(y))
if2(true, b2, b3, x, y) → 0
if2(false, b2, b3, x, y) → if3(b2, b3, x, y)
if3(true, b3, x, y) → 0
if3(false, b3, x, y) → if4(b3, x, y)
if4(true, x, y) → s(0)
if4(false, x, y) → average(s(x), p(p(y)))

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LE(s(x), s(y)) → LE(x, y)

R is empty.
The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LE(s(x), s(y)) → LE(x, y)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

LE(s(x), s(y)) → LE(x, y)
The graph contains the following edges 1 > 1, 2 > 2

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
IF(false, b1, b2, b3, x, y) → AVERAGE(p(x), s(y))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)
average(x, y) → if(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
if(true, b1, b2, b3, x, y) → if2(b1, b2, b3, x, y)
if(false, b1, b2, b3, x, y) → average(p(x), s(y))
if2(true, b2, b3, x, y) → 0
if2(false, b2, b3, x, y) → if3(b2, b3, x, y)
if3(true, b3, x, y) → 0
if3(false, b3, x, y) → if4(b3, x, y)
if4(true, x, y) → s(0)
if4(false, x, y) → average(s(x), p(p(y)))

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
IF(false, b1, b2, b3, x, y) → AVERAGE(p(x), s(y))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))
average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

average(x0, x1)
if(true, x0, x1, x2, x3, x4)
if(false, x0, x1, x2, x3, x4)
if2(true, x0, x1, x2, x3)
if2(false, x0, x1, x2, x3)
if3(true, x0, x1, x2)
if3(false, x0, x1, x2)
if4(true, x0, x1)
if4(false, x0, x1)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
IF(false, b1, b2, b3, x, y) → AVERAGE(p(x), s(y))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
In the following pairs the term without variables s(s(0)) is replaced by the fresh variable x_removed.
Pair: AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y)
Positions in right side of the pair:

[3,1]

The new variable was added to all pairs as a new argument[13].

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                          ↳ QDP

                        ↳ RemovalProof

                        ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(x, y, x_removed) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, x_removed), x, y, x_removed)
IF(true, b1, b2, b3, x, y, x_removed) → IF2(b1, b2, b3, x, y, x_removed)
IF4(false, x, y, x_removed) → AVERAGE(s(x), p(p(y)), x_removed)
IF(false, b1, b2, b3, x, y, x_removed) → AVERAGE(p(x), s(y), x_removed)
IF3(false, b3, x, y, x_removed) → IF4(b3, x, y, x_removed)
IF2(false, b2, b3, x, y, x_removed) → IF3(b2, b3, x, y, x_removed)

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

[3,1]

The new variable was added to all pairs as a new argument[13].

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                          ↳ QDP

                        ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(x, y, x_removed) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, x_removed), x, y, x_removed)
IF(true, b1, b2, b3, x, y, x_removed) → IF2(b1, b2, b3, x, y, x_removed)
IF4(false, x, y, x_removed) → AVERAGE(s(x), p(p(y)), x_removed)
IF(false, b1, b2, b3, x, y, x_removed) → AVERAGE(p(x), s(y), x_removed)
IF3(false, b3, x, y, x_removed) → IF4(b3, x, y, x_removed)
IF2(false, b2, b3, x, y, x_removed) → IF3(b2, b3, x, y, x_removed)

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule AVERAGE(x, y) → IF(le(x, 0), le(y, 0), le(y, s(0)), le(y, s(s(0))), x, y) at position [0] we obtained the following new rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
AVERAGE(0, y1) → IF(true, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), 0, y1)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(0, y1) → IF(true, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), 0, y1)
IF(false, b1, b2, b3, x, y) → AVERAGE(p(x), s(y))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule IF(false, b1, b2, b3, x, y) → AVERAGE(p(x), s(y)) at position [0] we obtained the following new rules:

IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
IF(false, y0, y1, y2, 0, y4) → AVERAGE(0, s(y4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF(false, y0, y1, y2, 0, y4) → AVERAGE(0, s(y4))
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(0, y1) → IF(true, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), 0, y1)
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(0, y1) → IF(true, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), 0, y1)
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule AVERAGE(0, y1) → IF(true, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), 0, y1) we obtained the following new rules:

AVERAGE(0, s(z4)) → IF(true, le(s(z4), 0), le(s(z4), s(0)), le(s(z4), s(s(0))), 0, s(z4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF3(false, b3, x, y) → IF4(b3, x, y)
AVERAGE(0, s(z4)) → IF(true, le(s(z4), 0), le(s(z4), s(0)), le(s(z4), s(s(0))), 0, s(z4))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(0, s(z4)) → IF(true, le(s(z4), 0), le(s(z4), s(0)), le(s(z4), s(s(0))), 0, s(z4)) at position [1] we obtained the following new rules:

AVERAGE(0, s(z4)) → IF(true, false, le(s(z4), s(0)), le(s(z4), s(s(0))), 0, s(z4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
AVERAGE(0, s(z4)) → IF(true, false, le(s(z4), s(0)), le(s(z4), s(s(0))), 0, s(z4))
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF3(false, b3, x, y) → IF4(b3, x, y)
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(0, s(z4)) → IF(true, false, le(s(z4), s(0)), le(s(z4), s(s(0))), 0, s(z4)) at position [2] we obtained the following new rules:

AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(s(z4), s(s(0))), 0, s(z4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(s(z4), s(s(0))), 0, s(z4))
IF3(false, b3, x, y) → IF4(b3, x, y)
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(s(z4), s(s(0))), 0, s(z4)) at position [3] we obtained the following new rules:

AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF3(false, b3, x, y) → IF4(b3, x, y)
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF(true, b1, b2, b3, x, y) → IF2(b1, b2, b3, x, y) we obtained the following new rules:

IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF3(false, b3, x, y) → IF4(b3, x, y)
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF2(false, b2, b3, x, y) → IF3(b2, b3, x, y) we obtained the following new rules:

IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF3(false, b3, x, y) → IF4(b3, x, y)
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF3(false, b3, x, y) → IF4(b3, x, y) we obtained the following new rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF4(false, x, y) → AVERAGE(s(x), p(p(y)))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF4(false, x, y) → AVERAGE(s(x), p(p(y))) we obtained the following new rules:

IF4(false, 0, s(z1)) → AVERAGE(s(0), p(p(s(z1))))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(p(s(z1))))
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule IF4(false, 0, s(z1)) → AVERAGE(s(0), p(p(s(z1)))) at position [1,0] we obtained the following new rules:

IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1)
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule AVERAGE(s(x0), y1) → IF(false, le(y1, 0), le(y1, s(0)), le(y1, s(s(0))), s(x0), y1) we obtained the following new rules:

AVERAGE(s(x0), s(z4)) → IF(false, le(s(z4), 0), le(s(z4), s(0)), le(s(z4), s(s(0))), s(x0), s(z4))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
AVERAGE(s(x0), s(z4)) → IF(false, le(s(z4), 0), le(s(z4), s(0)), le(s(z4), s(s(0))), s(x0), s(z4))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(x0), s(z4)) → IF(false, le(s(z4), 0), le(s(z4), s(0)), le(s(z4), s(s(0))), s(x0), s(z4)) at position [1] we obtained the following new rules:

AVERAGE(s(x0), s(z4)) → IF(false, false, le(s(z4), s(0)), le(s(z4), s(s(0))), s(x0), s(z4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(x0), s(z4)) → IF(false, false, le(s(z4), s(0)), le(s(z4), s(s(0))), s(x0), s(z4))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(x0), s(z4)) → IF(false, false, le(s(z4), s(0)), le(s(z4), s(s(0))), s(x0), s(z4)) at position [2] we obtained the following new rules:

AVERAGE(s(x0), s(z4)) → IF(false, false, le(z4, 0), le(s(z4), s(s(0))), s(x0), s(z4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
AVERAGE(s(x0), s(z4)) → IF(false, false, le(z4, 0), le(s(z4), s(s(0))), s(x0), s(z4))
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(x0), s(z4)) → IF(false, false, le(z4, 0), le(s(z4), s(s(0))), s(x0), s(z4)) at position [3] we obtained the following new rules:

AVERAGE(s(x0), s(z4)) → IF(false, false, le(z4, 0), le(z4, s(0)), s(x0), s(z4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(x0), s(z4)) → IF(false, false, le(z4, 0), le(z4, s(0)), s(x0), s(z4))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4))
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF(false, y0, y1, y2, s(x0), y4) → AVERAGE(x0, s(y4)) we obtained the following new rules:

IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF(false, false, y_0, y_1, s(z0), s(z1)) → AVERAGE(z0, s(s(z1)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(x0), s(z4)) → IF(false, false, le(z4, 0), le(z4, s(0)), s(x0), s(z4))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
IF(false, false, y_0, y_1, s(z0), s(z1)) → AVERAGE(z0, s(s(z1)))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule AVERAGE(s(x0), s(z4)) → IF(false, false, le(z4, 0), le(z4, s(0)), s(x0), s(z4)) we obtained the following new rules:

AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, le(s(z3), 0), le(s(z3), s(0)), s(x0), s(s(z3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, le(s(z3), 0), le(s(z3), s(0)), s(x0), s(s(z3)))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))
IF(false, false, y_0, y_1, s(z0), s(z1)) → AVERAGE(z0, s(s(z1)))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(x0), s(s(z3))) → IF(false, false, le(s(z3), 0), le(s(z3), s(0)), s(x0), s(s(z3))) at position [2] we obtained the following new rules:

AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(s(z3), s(0)), s(x0), s(s(z3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(s(z3), s(0)), s(x0), s(s(z3)))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
IF(false, false, y_0, y_1, s(z0), s(z1)) → AVERAGE(z0, s(s(z1)))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(s(z3), s(0)), s(x0), s(s(z3))) at position [3] we obtained the following new rules:

AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))
IF(false, false, y_0, y_1, s(z0), s(z1)) → AVERAGE(z0, s(s(z1)))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF(false, false, y_0, y_1, s(z0), s(z1)) → AVERAGE(z0, s(s(z1))) we obtained the following new rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF2(false, z0, z1, 0, s(z2)) → IF3(z0, z1, 0, s(z2)) we obtained the following new rules:

IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0))
IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF(true, false, y_0, y_1, 0, s(z0)) → IF2(false, y_0, y_1, 0, s(z0)) we obtained the following new rules:

IF(true, false, false, x1, 0, s(x2)) → IF2(false, false, x1, 0, s(x2))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(true, false, false, x1, 0, s(x2)) → IF2(false, false, x1, 0, s(x2))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule AVERAGE(0, s(z4)) → IF(true, false, le(z4, 0), le(z4, s(0)), 0, s(z4)) at position [2] we obtained the following new rules:

AVERAGE(0, s(0)) → IF(true, false, true, le(0, s(0)), 0, s(0))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(s(x0), s(0)), 0, s(s(x0)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
AVERAGE(0, s(0)) → IF(true, false, true, le(0, s(0)), 0, s(0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(s(x0), s(0)), 0, s(s(x0)))
IF(true, false, false, x1, 0, s(x2)) → IF2(false, false, x1, 0, s(x2))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(s(x0), s(0)), 0, s(s(x0)))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(true, false, false, x1, 0, s(x2)) → IF2(false, false, x1, 0, s(x2))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(0, s(s(x0))) → IF(true, false, false, le(s(x0), s(0)), 0, s(s(x0))) at position [3] we obtained the following new rules:

AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(true, false, false, x1, 0, s(x2)) → IF2(false, false, x1, 0, s(x2))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF(true, false, false, x1, 0, s(x2)) → IF2(false, false, x1, 0, s(x2)) we obtained the following new rules:

IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF2(false, false, x1, 0, s(x2)) → IF3(false, x1, 0, s(x2)) we obtained the following new rules:

IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF3(false, z1, 0, s(z2)) → IF4(z1, 0, s(z2)) we obtained the following new rules:

IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1))
IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF4(false, 0, s(z1)) → AVERAGE(s(0), p(z1)) we obtained the following new rules:

IF4(false, 0, s(s(z1))) → AVERAGE(s(0), p(s(z1)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(s(z1))) → AVERAGE(s(0), p(s(z1)))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))

The TRS R consists of the following rules:

p(s(x)) → x
p(0) → 0
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF4(false, 0, s(s(z1))) → AVERAGE(s(0), p(s(z1)))
IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)

The TRS R consists of the following rules:

p(s(x)) → x
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule IF4(false, 0, s(s(z1))) → AVERAGE(s(0), p(s(z1))) at position [1] we obtained the following new rules:

IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

p(s(x)) → x
le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

p(s(x0))
p(0)
le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

p(s(x0))
p(0)

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF(false, y_0, y_1, y_2, s(0), z0) → AVERAGE(0, s(z0)) we obtained the following new rules:

IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1)))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF3(false, z0, 0, s(s(z1))) → IF4(z0, 0, s(s(z1))) we obtained the following new rules:

IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF2(false, false, z0, 0, s(s(z1))) → IF3(false, z0, 0, s(s(z1))) we obtained the following new rules:

IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF(true, false, false, y_0, 0, s(s(z0))) → IF2(false, false, y_0, 0, s(s(z0))) we obtained the following new rules:

IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule AVERAGE(0, s(s(x0))) → IF(true, false, false, le(x0, 0), 0, s(s(x0))) at position [3] we obtained the following new rules:

AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(0, s(s(0))) → IF(true, false, false, true, 0, s(s(0)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)
AVERAGE(0, s(s(0))) → IF(true, false, false, true, 0, s(s(0)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0)
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule AVERAGE(s(0), y_0) → IF(false, le(y_0, 0), le(y_0, s(0)), le(y_0, s(s(0))), s(0), y_0) we obtained the following new rules:

AVERAGE(s(0), s(y_4)) → IF(false, le(s(y_4), 0), le(s(y_4), s(0)), le(s(y_4), s(s(0))), s(0), s(y_4))
AVERAGE(s(0), s(s(y_5))) → IF(false, le(s(s(y_5)), 0), le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(y_4)) → IF(false, le(s(y_4), 0), le(s(y_4), s(0)), le(s(y_4), s(s(0))), s(0), s(y_4))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
AVERAGE(s(0), s(s(y_5))) → IF(false, le(s(s(y_5)), 0), le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(y_4)) → IF(false, le(s(y_4), 0), le(s(y_4), s(0)), le(s(y_4), s(s(0))), s(0), s(y_4)) at position [1] we obtained the following new rules:

AVERAGE(s(0), s(y_4)) → IF(false, false, le(s(y_4), s(0)), le(s(y_4), s(s(0))), s(0), s(y_4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
AVERAGE(s(0), s(y_4)) → IF(false, false, le(s(y_4), s(0)), le(s(y_4), s(s(0))), s(0), s(y_4))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
AVERAGE(s(0), s(s(y_5))) → IF(false, le(s(s(y_5)), 0), le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(s(y_5))) → IF(false, le(s(s(y_5)), 0), le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5))) at position [1] we obtained the following new rules:

AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(0), s(y_4)) → IF(false, false, le(s(y_4), s(0)), le(s(y_4), s(s(0))), s(0), s(y_4))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(y_4)) → IF(false, false, le(s(y_4), s(0)), le(s(y_4), s(s(0))), s(0), s(y_4)) at position [2] we obtained the following new rules:

AVERAGE(s(0), s(y_4)) → IF(false, false, le(y_4, 0), le(s(y_4), s(s(0))), s(0), s(y_4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(s(0), s(y_4)) → IF(false, false, le(y_4, 0), le(s(y_4), s(s(0))), s(0), s(y_4))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(s(y_5)), s(0)), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5))) at position [2] we obtained the following new rules:

AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(y_5), 0), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(s(0), s(y_4)) → IF(false, false, le(y_4, 0), le(s(y_4), s(s(0))), s(0), s(y_4))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)
AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(y_5), 0), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(y_4)) → IF(false, false, le(y_4, 0), le(s(y_4), s(s(0))), s(0), s(y_4)) at position [3] we obtained the following new rules:

AVERAGE(s(0), s(y_4)) → IF(false, false, le(y_4, 0), le(y_4, s(0)), s(0), s(y_4))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)
AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(y_5), 0), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(s(y_5))) → IF(false, false, le(s(y_5), 0), le(s(s(y_5)), s(s(0))), s(0), s(s(y_5))) at position [2] we obtained the following new rules:

AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(s(s(y_5)), s(s(0))), s(0), s(s(y_5)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(s(s(y_5)), s(s(0))), s(0), s(s(y_5))) at position [3] we obtained the following new rules:

AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(s(y_5), s(0)), s(0), s(s(y_5)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(s(y_5), s(0)), s(0), s(s(y_5)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(s(y_5), s(0)), s(0), s(s(y_5))) at position [3] we obtained the following new rules:

AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF(false, x0, x1, x2, s(0), s(y_0)) → AVERAGE(0, s(s(y_0))) we obtained the following new rules:

IF(false, false, y_0, y_1, s(0), s(z0)) → AVERAGE(0, s(s(z0)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1)
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF4(false, 0, s(s(z1))) → AVERAGE(s(0), z1) we obtained the following new rules:

IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3)))
AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF(false, false, y_1, y_2, s(0), s(x3)) → AVERAGE(0, s(s(x3))) we obtained the following new rules:

IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0))))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0))))
IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF(false, false, false, y_0, s(z0), s(s(z1))) → AVERAGE(z0, s(s(s(z1)))) we obtained the following new rules:

IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF(false, false, false, x0, s(0), s(s(x2))) → AVERAGE(0, s(s(s(x2))))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0))))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule AVERAGE(s(0), s(x1)) → IF(false, false, le(x1, 0), le(x1, s(0)), s(0), s(x1)) we obtained the following new rules:

AVERAGE(s(0), s(s(y_4))) → IF(false, false, le(s(y_4), 0), le(s(y_4), s(0)), s(0), s(s(y_4)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(0), s(s(y_4))) → IF(false, false, le(s(y_4), 0), le(s(y_4), s(0)), s(0), s(s(y_4)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0))))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(s(y_4))) → IF(false, false, le(s(y_4), 0), le(s(y_4), s(0)), s(0), s(s(y_4))) at position [2] we obtained the following new rules:

AVERAGE(s(0), s(s(y_4))) → IF(false, false, false, le(s(y_4), s(0)), s(0), s(s(y_4)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(0), s(s(y_4))) → IF(false, false, false, le(s(y_4), s(0)), s(0), s(s(y_4)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0))))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule AVERAGE(s(0), s(s(y_4))) → IF(false, false, false, le(s(y_4), s(0)), s(0), s(s(y_4))) at position [3] we obtained the following new rules:

AVERAGE(s(0), s(s(y_4))) → IF(false, false, false, le(y_4, 0), s(0), s(s(y_4)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0))))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false
le(s(x), s(y)) → le(x, y)

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0))))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule IF(false, false, x0, x1, s(0), s(s(y_0))) → AVERAGE(0, s(s(s(y_0)))) we obtained the following new rules:

IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3)))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule AVERAGE(s(x0), s(s(z3))) → IF(false, false, false, le(z3, 0), s(x0), s(s(z3))) we obtained the following new rules:

AVERAGE(s(s(y_4)), s(s(x1))) → IF(false, false, false, le(x1, 0), s(s(y_4)), s(s(x1)))
AVERAGE(s(s(0)), s(s(x1))) → IF(false, false, false, le(x1, 0), s(s(0)), s(s(x1)))
AVERAGE(s(0), s(s(x1))) → IF(false, false, false, le(x1, 0), s(0), s(s(x1)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
AVERAGE(s(s(0)), s(s(x1))) → IF(false, false, false, le(x1, 0), s(s(0)), s(s(x1)))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
IF(false, false, false, x0, s(s(0)), s(s(x2))) → AVERAGE(s(0), s(s(s(x2))))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(s(y_4)), s(s(x1))) → IF(false, false, false, le(x1, 0), s(s(y_4)), s(s(x1)))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 1 less node.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                      ↳ AND

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                        ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule IF4(false, 0, s(s(s(y_0)))) → AVERAGE(s(0), s(y_0)) we obtained the following new rules:

IF4(false, 0, s(s(s(s(y_0))))) → AVERAGE(s(0), s(s(y_0)))

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                      ↳ AND

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                        ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))
IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

IF4(false, 0, s(s(s(s(y_1))))) → AVERAGE(s(0), s(s(y_1)))

The remaining pairs can at least be oriented weakly.

IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(AVERAGE(x₁, x₂)) = x₁ + x₂
POL(IF(x₁, x₂, x₃, x₄, x₅, x₆)) = x₅ + x₆
POL(IF2(x₁, x₂, x₃, x₄, x₅)) = x₅
POL(IF3(x₁, x₂, x₃, x₄)) = x₄
POL(IF4(x₁, x₂, x₃)) = x₃
POL(false) = 0
POL(le(x₁, x₂)) = 0
POL(s(x₁)) = 1 + x₁
POL(true) = 0

The following usable rules [17] were oriented: none

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                      ↳ AND

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                            ↳ QDP

                                                                                                                                                                                                                                                                              ↳ QDPOrderProof

                                                                                                                                                                                                                                                                                ↳ QDP

                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                        ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(0, s(s(s(x0)))) → IF(true, false, false, false, 0, s(s(s(x0))))
IF2(false, false, false, 0, s(s(x1))) → IF3(false, false, 0, s(s(x1)))
IF(true, false, false, false, 0, s(s(x1))) → IF2(false, false, false, 0, s(s(x1)))
IF3(false, false, 0, s(s(x1))) → IF4(false, 0, s(s(x1)))
IF(false, false, false, y_0, s(0), s(s(z1))) → AVERAGE(0, s(s(s(z1))))
AVERAGE(s(0), s(s(y_5))) → IF(false, false, false, le(y_5, 0), s(0), s(s(y_5)))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 6 less nodes.

↳ QTRS

  ↳ Overlay + Local Confluence

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ RemovalProof

                        ↳ RemovalProof

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ Instantiation

                                      ↳ QDP

                                        ↳ Rewriting

                                          ↳ QDP

                                            ↳ Rewriting

                                              ↳ QDP

                                                ↳ Rewriting

                                                  ↳ QDP

                                                    ↳ Instantiation

                                                      ↳ QDP

                                                        ↳ Instantiation

                                                          ↳ QDP

                                                            ↳ Instantiation

                                                              ↳ QDP

                                                                ↳ Instantiation

                                                                  ↳ QDP

                                                                    ↳ Rewriting

                                                                      ↳ QDP

                                                                        ↳ Instantiation

                                                                          ↳ QDP

                                                                            ↳ Rewriting

                                                                              ↳ QDP

                                                                                ↳ Rewriting

                                                                                  ↳ QDP

                                                                                    ↳ Rewriting

                                                                                      ↳ QDP

                                                                                        ↳ Instantiation

                                                                                          ↳ QDP

                                                                                            ↳ Instantiation

                                                                                              ↳ QDP

                                                                                                ↳ Rewriting

                                                                                                  ↳ QDP

                                                                                                    ↳ Rewriting

                                                                                                      ↳ QDP

                                                                                                        ↳ Instantiation

                                                                                                          ↳ QDP

                                                                                                            ↳ ForwardInstantiation

                                                                                                              ↳ QDP

                                                                                                                ↳ ForwardInstantiation

                                                                                                                  ↳ QDP

                                                                                                                    ↳ Narrowing

                                                                                                                      ↳ QDP

                                                                                                                        ↳ DependencyGraphProof

                                                                                                                          ↳ QDP

                                                                                                                            ↳ Rewriting

                                                                                                                              ↳ QDP

                                                                                                                                ↳ Instantiation

                                                                                                                                  ↳ QDP

                                                                                                                                    ↳ Instantiation

                                                                                                                                      ↳ QDP

                                                                                                                                        ↳ Instantiation

                                                                                                                                          ↳ QDP

                                                                                                                                            ↳ Instantiation

                                                                                                                                              ↳ QDP

                                                                                                                                                ↳ UsableRulesProof

                                                                                                                                                  ↳ QDP

                                                                                                                                                    ↳ Rewriting

                                                                                                                                                      ↳ QDP

                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                          ↳ QDP

                                                                                                                                                            ↳ QReductionProof

                                                                                                                                                              ↳ QDP

                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                  ↳ QDP

                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                      ↳ QDP

                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                          ↳ QDP

                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                ↳ Narrowing

                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                            ↳ Rewriting

                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                        ↳ Rewriting

                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                    ↳ ForwardInstantiation

                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                        ↳ ForwardInstantiation

                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                            ↳ ForwardInstantiation

                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                ↳ Rewriting

                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                    ↳ Rewriting

                                                                                                                                                                                                                                                      ↳ QDP

                                                                                                                                                                                                                                                        ↳ UsableRulesProof

                                                                                                                                                                                                                                                          ↳ QDP

                                                                                                                                                                                                                                                            ↳ Instantiation

                                                                                                                                                                                                                                                              ↳ QDP

                                                                                                                                                                                                                                                                ↳ ForwardInstantiation

                                                                                                                                                                                                                                                                  ↳ QDP

                                                                                                                                                                                                                                                                    ↳ DependencyGraphProof

                                                                                                                                                                                                                                                                      ↳ AND

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                        ↳ QDP

                                                                                                                                                                                                                                                                          ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

AVERAGE(s(s(y_4)), s(s(x1))) → IF(false, false, false, le(x1, 0), s(s(y_4)), s(s(x1)))
AVERAGE(s(s(0)), s(s(x1))) → IF(false, false, false, le(x1, 0), s(s(0)), s(s(x1)))
IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))

The TRS R consists of the following rules:

le(0, y) → true
le(s(x), 0) → false

The set Q consists of the following terms:

le(0, x0)
le(s(x0), 0)
le(s(x0), s(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

IF(false, false, false, x0, s(s(y_0)), s(s(x2))) → AVERAGE(s(y_0), s(s(s(x2))))
The graph contains the following edges 5 > 1
AVERAGE(s(s(y_4)), s(s(x1))) → IF(false, false, false, le(x1, 0), s(s(y_4)), s(s(x1)))
The graph contains the following edges 1 >= 5, 2 >= 6
AVERAGE(s(s(0)), s(s(x1))) → IF(false, false, false, le(x1, 0), s(s(0)), s(s(x1)))
The graph contains the following edges 1 >= 5, 2 >= 6